/**
 * Redis API 封装模块（基于连接池）
 * @author HalRui
 * @version 1.0.0
 * @description 提供统一的 Redis 操作接口，使用连接池管理连接，封装验证码、令牌等常用操作
 * @date 2025年9月27日
 */

/**
 * Redis API 封装（基于连接池）
 * 提供统一的 Redis 操作接口，使用连接池管理连接
 * 现在使用 connection-pool 管理的统一连接
 */

const connectionPool = require("../utils/connection-pool");
const config = require("../env.config.json");

// 获取 Redis 客户端实例（由 connection-pool 统一管理）
function getRedisClient() {
    return connectionPool.getRedisClient();
}

module.exports = {
    /**
     * 保存邮箱验证码
     * @param email {String} : 邮箱地址
     * @param code {String} : 验证码
     * @param ttl {Number} : 过期时间(秒)，默认5分钟
     * @returns {Object} : 包含success和message的对象
     */
    saveEmailCode: async function (email, code, ttl = 300) {
        try {
            const redisClient = getRedisClient();
            const key = `email_code:${email}`;
            await redisClient.select(config.redis.emailDb);
            await redisClient.setEx(key, ttl, code);
            return {
                success: true,
                message: '邮箱验证码保存成功'
            };
        } catch (error) {
            console.error(`保存邮箱验证码失败 [${email}]:`, error);
            return {
                success: false,
                message: '存储email code 失败'
            };
        }
    },

    /**
     * 获取邮箱验证码
     * @param email {String} : 邮箱地址
     * @returns {Object} : 包含success和message的对象
     */
    getEmailCode: async function (email) {
        try {
            const redisClient = getRedisClient();
            const key = `email_code:${email}`;
            await redisClient.select(config.redis.emailDb);
            const code = await redisClient.get(key);
            return {
                success: true,
                message: code
            };
        } catch (error) {
            console.error(`获取邮箱验证码失败 [${email}]:`, error);
            return {
                success: false,
                message: '获取email code 失败'
            };
        }
    },
    /**
     *
     *
     */
    dropEmailCode : async function (key){
        try {
            const redisClient = getRedisClient();
            const result = await redisClient.del(key);
            return {
                success: true,
                message: result
            };
        } catch (error) {
            console.error('Redis健康检查失败:', error);
            return {
                success: false,
                message: 'Redis健康检查失败'
            };
        }
    },
    /**
     * 保存验证码
     * @param uuid {String} : 验证码UUID
     * @param captcha {String} : 验证码
     * @param ttl {Number} : 过期时间(秒)，默认5分钟
     * @returns {Object} : 包含success和message的对象
     */
    setCaptcha: async function (uuid, captcha, ttl = 300) {
        try {
            const redisClient = getRedisClient();
            const key = `captcha:${uuid}`;
            await redisClient.select(config.redis.captchaDb);
            await redisClient.setEx(key, ttl, captcha); // 5分钟过期
            return {
                success: true,
                message: '验证码保存成功'
            };
        } catch (error) {
            console.error(`保存验证码失败 [${uuid}]:`, error);
            return {
                success: false,
                message: '存储验证码失败'
            };
        }
    },

    /**
     * 获取验证码
     * @param uuid {String} : 验证码UUID
     * @returns {Object} : 包含success和message的对象
     */
    getCaptcha: async function (uuid) {
        try {
            const redisClient = getRedisClient();
            const key = `captcha:${uuid}`;
            await redisClient.select(config.redis.captchaDb);
            const captcha = await redisClient.get(key);
            return {
                success: true,
                message: captcha
            };
        } catch (error) {
            console.error(`获取验证码失败 [${uuid}]:`, error);
            return {
                success: false,
                message: '获取验证码失败'
            };
        }
    },

    /**
     * 删除验证码
     * @param uuid {String} : 验证码UUID
     * @returns {Object} : 包含success和message的对象
     */
    deleteCaptcha: async function (uuid) {
        try {
            const redisClient = getRedisClient();
            const key = `captcha:${uuid}`;
            await redisClient.select(config.redis.captchaDb);
            const result = await redisClient.del(key);
            return {
                success: true,
                message: result
            };
        } catch (error) {
            console.error(`删除验证码失败 [${uuid}]:`, error);
            return {
                success: false,
                message: '删除验证码失败'
            };
        }
    },

    /**
     * 保存刷新令牌
     * @param refreshToken {String} : 刷新令牌
     * @param ttl {Number} : 过期时间(秒)，默认7天
     * @returns {Object} : 包含success和message的对象
     */
    setRefreshToken: async function (refreshToken, ttl = 7 * 24 * 60 * 60) {
        try {
            const redisClient = getRedisClient();
            const key = `refresh_token:${refreshToken}`;
            await redisClient.select(config.redis.userDb);
            await redisClient.setEx(key, ttl, '1'); // 7天过期
            return {
                success: true,
                message: '刷新令牌保存成功'
            };
        } catch (error) {
            console.error(`保存刷新令牌失败:`, error);
            return {
                success: false,
                message: '存储刷新令牌失败'
            };
        }
    },

    /**
     * 检查令牌是否存在
     * @param refreshToken {String} : 刷新令牌
     * @returns {Object} : 包含success和message的对象
     */
    isExists: async function (refreshToken) {
        try {
            const redisClient = getRedisClient();
            const key = `refresh_token:${refreshToken}`;
            await redisClient.select(config.redis.userDb);
            const result = await redisClient.exists(key);
            return {
                success: true,
                message: result === 1
            };
        } catch (error) {
            console.error(`检查令牌状态失败:`, error);
            return {
                success: false,
                message: '检查令牌状态失败'
            };
        }
    },

    /**
     * 获取连接状态（使用 connection-pool 的状态）
     * @returns {Object} : 包含success和message的对象
     */
    getConnectionStatus: function () {
        const status = connectionPool.getConnectionStatus().redis;
        return {
            success: true,
            message: status
        };
    },

    /**
     * 健康检查（使用 connection-pool 的健康检查）
     * @returns {Object} : 包含success和message的对象
     */
    healthCheck: async function () {
        try {
            const fullHealth = await connectionPool.healthCheck();
            return {
                success: true,
                message: fullHealth.redis
            };
        } catch (error) {
            console.error('Redis健康检查失败:', error);
            return {
                success: false,
                message: 'Redis健康检查失败'
            };
        }
    }

}